package com.example.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;

@Service
@Slf4j
public class CompletableFutureExampleService {

    public CompletableFuture<String> executeAsyncTask() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "异步任务完成";
        });
    }

    /**
     * 执行一个异步任务，并通过 CompletableFuture 的各种 API 展示常见的操作链。
     * 该方法模拟了多个任务的组合、异常处理以及任务完成后的操作。
     *
     * @return 一个包含任务结果的 CompletableFuture
     */
    public CompletableFuture<String> executeComplexAsyncTask() {
        log.info("开始异步任务");

        // Step 1: 异步任务，返回 "Task 1 完成"
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            log.info("执行 Task 1...");
            try {
                Thread.sleep(2000); // 模拟任务耗时
            } catch (InterruptedException e) {
                log.error("Task 1 被中断", e);
            }
            return "Task 1 完成";
        });

        // Step 2: 在 Task 1 完成后执行，处理结果并继续链式操作
        CompletableFuture<String> task2 = task1.thenApply(result -> {
            log.info("Task 1 完成，结果: {}", result);
            log.info("执行 Task 2...");
            try {
                Thread.sleep(1000); // 模拟任务耗时
            } catch (InterruptedException e) {
                log.error("Task 2 被中断", e);
            }
            return "Task 2 完成";
        });

        // Step 3: 并行执行另一个异步任务，并合并结果
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
            log.info("执行 Task 3...");
            try {
                Thread.sleep(1500); // 模拟任务耗时
            } catch (InterruptedException e) {
                log.error("Task 3 被中断", e);
            }
            return "Task 3 完成";
        });

        // 合并 Task 2 和 Task 3 的结果
        CompletableFuture<String> combinedTask = task2.thenCombine(task3, (result2, result3) -> {
            log.info("Task 2 和 Task 3 合并结果: {}, {}", result2, result3);
            return result2 + " & " + result3;
        });

        // 捕获异常并处理
        CompletableFuture<String> finalTask = combinedTask.exceptionally(ex -> {
            log.error("任务执行中遇到异常", ex);
            return "任务失败";
        });

        // 任务完成后执行的操作
        finalTask.thenAccept(result -> log.info("最终结果: {}", result));

        return finalTask;
    }


}
